package com.hducms.common.util;

import java.security.InvalidParameterException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;

import javax.crypto.Cipher;
import org.apache.commons.lang.StringUtils;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.encoders.Hex;



public class RSA {
	/** 算法名称 */
    private static final String ALGORITHOM = "RSA";

    /** 密钥大小 */
    private static final int KEY_SIZE = 1024;
    /** 默认的安全服务提供者 */
    private static final Provider DEFAULT_PROVIDER = new BouncyCastleProvider();

    private static KeyPairGenerator keyPairGen = null;
    private static KeyFactory keyFactory = null;
    /** 缓存的密钥对。 */
    private  KeyPair oneKeyPair;
    private  RSAPrivateKey privateKey;
    
    public RSA() {
	    this.generateKeyPair();
	}

    static {
        try {
            keyPairGen = KeyPairGenerator.getInstance(ALGORITHOM,
                    DEFAULT_PROVIDER);
            keyFactory = KeyFactory.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
        } catch (NoSuchAlgorithmException ex) {
            ex.printStackTrace();
        }
    }

    /**
     * 生成并返回RSA密钥对。
     */
    private  synchronized KeyPair generateKeyPair() {
        try {
//            keyPairGen.initialize(KEY_SIZE,
//                    new SecureRandom(radamKey.getBytes()));
        	keyPairGen.initialize(KEY_SIZE);
            oneKeyPair = keyPairGen.generateKeyPair();
            return oneKeyPair;
        } catch (InvalidParameterException ex) {
            ex.printStackTrace();
        } catch (NullPointerException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /** 返回已初始化的默认的公钥。 */
    public  RSAPublicKey getDefaultPublicKey() {
        if (oneKeyPair != null) {
            return (RSAPublicKey) oneKeyPair.getPublic();
        }
        return null;
    }
    /**返回已初始化的默认的私钥。  */
    public  RSAPrivateKey getDefaultPrivateKey(){
    	if (oneKeyPair != null) {
			return (RSAPrivateKey)oneKeyPair.getPrivate();
		}
    	return null;
    }
     /**
     * 使用指定的私钥解密数据。
     * 
     * @param privateKey 给定的私钥。
     * @param data 要解密的数据。
     * @return 原数据。
     */
    public  byte[] decrypt(PrivateKey privateKey, byte[] data) throws Exception {
        Cipher ci = Cipher.getInstance(ALGORITHOM, DEFAULT_PROVIDER);
        ci.init(Cipher.DECRYPT_MODE, privateKey);
        return ci.doFinal(data);
    }
    
    /**
     * 使用默认的私钥解密给定的字符串。
     * <p />
     * 若{@code encrypttext} 为 {@code null}或空字符串则返回 {@code null}。
     * 私钥不匹配时，返回 {@code null}。
     * 
     * @param encrypttext 密文。
     * @return 原文字符串。
     */
    public  String decryptString(String encrypttext) {
        if(StringUtils.isBlank(encrypttext)) {
            return null;
        }
//        KeyPair keyPair = generateKeyPair();
        try {
            byte[] en_data = Hex.decode(encrypttext);
//            byte[] data = decrypt((RSAPrivateKey)keyPair.getPrivate(), en_data);
            byte[] data = decrypt(privateKey, en_data);
            return new String(data);
        } catch(NullPointerException ex) {
            ex.printStackTrace();
        } catch (Exception ex) {
           ex.printStackTrace();
        }
        return null;
    }
    
    /**
     * 使用默认的私钥解密由JS加密（使用此类提供的公钥加密）的字符串。
     * 
     * @param encrypttext 密文。
     * @return {@code encrypttext} 的原文字符串。
     */
    public  String decryptStringByJs(String encrypttext) {
        String text = decryptString(encrypttext);
        if(text == null) {
            return null;
        }
        return StringUtils.reverse(text);
    }

	public void setPrivateKey(RSAPrivateKey privateKey) {
		this.privateKey = privateKey;
	}
}
